<!--
@license
Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
Code distributed by Google as part of the polymer project is also
subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
-->

<link rel="import" href="../polymer/polymer.html">

<script>
  (function() {

  // Contains all connected resizables that do not have a parent.
  var ORPHANS = new Set();

  /**
   * `IronResizableBehavior` is a behavior that can be used in Polymer elements to
   * coordinate the flow of resize events between "resizers" (elements that
   *control the size or hidden state of their children) and "resizables" (elements
   *that need to be notified when they are resized or un-hidden by their parents
   *in order to take action on their new measurements).
   *
   * Elements that perform measurement should add the `IronResizableBehavior`
   *behavior to their element definition and listen for the `iron-resize` event on
   *themselves. This event will be fired when they become showing after having
   *been hidden, when they are resized explicitly by another resizable, or when
   *the window has been resized.
   *
   * Note, the `iron-resize` event is non-bubbling.
   *
   * @polymerBehavior Polymer.IronResizableBehavior
   * @demo demo/index.html
   **/
  Polymer.IronResizableBehavior = {
    properties: {
      /**
       * The closest ancestor element that implements `IronResizableBehavior`.
       */
      _parentResizable: {type: Object, observer: '_parentResizableChanged'},

      /**
       * True if this element is currently notifying its descendant elements of
       * resize.
       */
      _notifyingDescendant: {type: Boolean, value: false}
    },

    listeners: {
      'iron-request-resize-notifications': '_onIronRequestResizeNotifications'
    },

    created: function() {
      // We don't really need property effects on these, and also we want them
      // to be created before the `_parentResizable` observer fires:
      this._interestedResizables = [];
      this._boundNotifyResize = this.notifyResize.bind(this);
    },

    attached: function() {
      this._requestResizeNotifications();
    },

    detached: function() {
      if (this._parentResizable) {
        this._parentResizable.stopResizeNotificationsFor(this);
      } else {
        ORPHANS.delete(this);
        window.removeEventListener('resize', this._boundNotifyResize);
      }

      this._parentResizable = null;
    },

    /**
     * Can be called to manually notify a resizable and its descendant
     * resizables of a resize change.
     */
    notifyResize: function() {
      if (!this.isAttached) {
        return;
      }

      this._interestedResizables.forEach(function(resizable) {
        if (this.resizerShouldNotify(resizable)) {
          this._notifyDescendant(resizable);
        }
      }, this);

      this._fireResize();
    },

    /**
     * Used to assign the closest resizable ancestor to this resizable
     * if the ancestor detects a request for notifications.
     */
    assignParentResizable: function(parentResizable) {
      if (this._parentResizable) {
        this._parentResizable.stopResizeNotificationsFor(this);
      }

      this._parentResizable = parentResizable;

      if (parentResizable &&
          parentResizable._interestedResizables.indexOf(this) === -1) {
        parentResizable._interestedResizables.push(this);
        parentResizable.listen(this, 'iron-resize', '_onDescendantIronResize');
      }
    },

    /**
     * Used to remove a resizable descendant from the list of descendants
     * that should be notified of a resize change.
     */
    stopResizeNotificationsFor: function(target) {
      var index = this._interestedResizables.indexOf(target);

      if (index > -1) {
        this._interestedResizables.splice(index, 1);
        this.unlisten(target, 'iron-resize', '_onDescendantIronResize');
      }
    },

    /**
     * This method can be overridden to filter nested elements that should or
     * should not be notified by the current element. Return true if an element
     * should be notified, or false if it should not be notified.
     *
     * @param {HTMLElement} element A candidate descendant element that
     * implements `IronResizableBehavior`.
     * @return {boolean} True if the `element` should be notified of resize.
     */
    resizerShouldNotify: function(element) {
      return true;
    },

    _onDescendantIronResize: function(event) {
      if (this._notifyingDescendant) {
        event.stopPropagation();
        return;
      }

      // NOTE(cdata): In ShadowDOM, event retargeting makes echoing of the
      // otherwise non-bubbling event "just work." We do it manually here for
      // the case where Polymer is not using shadow roots for whatever reason:
      if (!Polymer.Settings.useShadow) {
        this._fireResize();
      }
    },

    _fireResize: function() {
      this.fire('iron-resize', null, {node: this, bubbles: false});
    },

    _onIronRequestResizeNotifications: function(event) {
      var target = /** @type {!EventTarget} */ (Polymer.dom(event).rootTarget);
      if (target === this) {
        return;
      }

      target.assignParentResizable(this);
      this._notifyDescendant(target);

      event.stopPropagation();
    },

    _parentResizableChanged: function(parentResizable) {
      if (parentResizable) {
        window.removeEventListener('resize', this._boundNotifyResize);
      }
    },

    _notifyDescendant: function(descendant) {
      // NOTE(cdata): In IE10, attached is fired on children first, so it's
      // important not to notify them if the parent is not attached yet (or
      // else they will get redundantly notified when the parent attaches).
      if (!this.isAttached) {
        return;
      }

      this._notifyingDescendant = true;
      descendant.notifyResize();
      this._notifyingDescendant = false;
    },

    _requestResizeNotifications: function() {
      if (!this.isAttached)
        return;

      // NOTE(valdrin) In CustomElements v1 with native HTMLImports, the order
      // of imports affects the order of `attached` callbacks (see
      // webcomponents/custom-elements#15). This might cause a child to notify
      // parents too early (as the parent still has to be upgraded), resulting in
      // a parent not able to keep track of the `_interestedResizables`. To solve
      // this, we wait for the document to be done loading before firing the
      // event.
      if (document.readyState === 'loading') {
        var _requestResizeNotifications =
            this._requestResizeNotifications.bind(this);
        document.addEventListener(
            'readystatechange', function readystatechanged() {
              document.removeEventListener('readystatechange', readystatechanged);
              _requestResizeNotifications();
            });
      } else {
        this._findParent();

        if (!this._parentResizable) {
          // If this resizable is an orphan, tell other orphans to try to find
          // their parent again, in case it's this resizable.
          ORPHANS.forEach(function(orphan) {
            if (orphan !== this) {
              orphan._findParent();
            }
          }, this);

          window.addEventListener('resize', this._boundNotifyResize);
          this.notifyResize();
        } else {
          // If this resizable has a parent, tell other child resizables of
          // that parent to try finding their parent again, in case it's this
          // resizable.
          this._parentResizable._interestedResizables
              .forEach(function(resizable) {
                if (resizable !== this) {
                  resizable._findParent();
                }
              }, this);
        }
      }
    },

    _findParent: function() {
      this.assignParentResizable(null);
      this.fire(
          'iron-request-resize-notifications',
          null,
          {node: this, bubbles: true, cancelable: true});

      if (!this._parentResizable) {
        ORPHANS.add(this);
      } else {
        ORPHANS.delete(this);
      }
    }
  };
  })();
</script>
